Data Structures & Algorithms in Python: Fundamental Data Structures

Data Structures & Algorithms in Python: Fundamental Data Structures

• discover the key concepts covered in this course
• identify what makes a data structure and some of the purposes they serve
• recall the metrics on which algorithms and operations on data are evaluated
• recognize how the performance of operations and algorithms is expressed in terms of the size of the input
• describe a linked list, and its contents and structure
• summarize the different ways in which nodes can be added to a linked list and how search operations work on this data structure
• recall different methods to remove nodes from a linked list and describe the process of reversing the order of nodes in this data structure
• describe techniques used to keep track of the number of elements in a linked list
• summarize the workings of a stack data structure, including the addition and removal of elements
• identify some of the operations on stacks, such as ISEMPTY and ISFULL, and recall the complexities of the different stack operations
• describe the queue data structure and compare it to stacks
• summarize the time complexities of the common operations on linked lists and compare the stack and queue data structures

Explore Python data structures and delve into the details of some of the basic data structures, such as linked lists, stacks, and queues.

Data Structures & Algorithms in Python: Implementing Data Structures

Data Structures & Algorithms in Python: Implementing Data Structures

• discover the key concepts covered in this course
• identify operations that run in constant time regardless of input
• recognize code whose time complexity varies directly with the value of the input
• identify tasks whose time complexity varies linearly with the size of the input
• recognize operations whose time complexity varies as the square of the input size
• use the native Queue class of Python and perform the standard queue operations on it
• code a bespoke Queue class that includes definitions for many of the standard queue operations, such as enqueue and dequeue
• recognize how a Python list can be used as a stack by loading and unloading elements from the same end
• implement a custom Stack class that includes functions for the common stack operations
• define a Linked List class and implement functions to insert a node at the head or the tail of the linked list
• code functions to perform search and delete operations in a linked list and to reverse the ordering of its nodes
• instantiate a Linked List and test out the various operations that have been defined
• summarize common operations on stacks and their time complexities, and list the situations when adding to or removing elements from a stack or queue can throw exceptions

Begin by examining operations that have different values of time complexity. Then delve into the implementation of some of the basic data structures, such as linked lists, stacks, and queues in Python.

Data Structures & Algorithms in Python: Implementing Sorting Algorithms

Data Structures & Algorithms in Python: Implementing Sorting Algorithms

• discover the key concepts covered in this course
• write the code to implement a Selection Sort
• implement the Bubble Sort algorithm in Python
• code a function to implement the Insertion Sort algorithm
• write the code to implement the divide-and-conquer Shell Sort algorithm
• invoke the Shell Sort algorithm on an array of integers and examine the output at each iteration to understand how it works
• code a function to implement the Merge Sort algorithm and test it on an array of integers
• write the partition and Quicksort functions in order to implement a Quicksort
• apply Quicksort on an array of integers and analyze the results at each iteration to understand how the algorithm works
• describe the Bubble Sort algorithm and summarize the two functions needed to implement the Quicksort algorithm

Examine the Python implementation of common sorting algorithms such as Selection Sort, Bubble Sort, and Insertion Sort, as well as divide and conquer sorts such as Shell Sort, Merge Sort, and Quicksort.

Data Structures & Algorithms in Python: Implementing Trees & Graphs

Data Structures & Algorithms in Python: Implementing Trees & Graphs

• discover the key concepts covered in this course
• code a function to perform a binary search on a sorted array of elements
• define the classes and functions required to implement a binary search tree
• create functions to perform common BST operations such as lookup and finding the minimum and maximum values
• write a function to perform a breadth first traversal of a BST
• code functions to perform pre-order, in-order, and post-order traversals of a BST
• define an abstract base class for a graph implementation and a vertex class with an adjacency set
• implement an adjacency set representation for a graph
• build a graph represented as an adjacency set and test out the functions defined to work with it
• define a class to represent a graph in the form of an adjacency matrix
• code a function to perform a breadth first traversal of a graph
• write a function to traverse a graph in a depth first manner
• implement a topological sort of a directed acyclic graph
• list the three different forms of depth first traversal of a binary tree and describe the Topological Sort algorithm for a graph

Discover how to implement trees and graphs and examine with the associated functions used to build and maintain these data structures in Python. In addition, explore algorithms for data structure traversal.

Data Structures & Algorithms in Python: Sorting Algorithms

Data Structures & Algorithms in Python: Sorting Algorithms

• discover the key concepts covered in this course
• identify the various properties of sorting algorithms that must be considered when selecting the right one for your data
• describe the operations involved when sorting a list of values using the Selection Sort algorithm
• summarize the process of a Bubble Sort when applied to a list of values
• recall the performance of the Bubble Sort on various measures such as time, space, and number of swaps
• describe the steps involved in performing an Insertion Sort and compare it to the Bubble Sort
• outline the workings of the Shell Sort and recall the performance metrics of this divide and conquer algorithm
• describe the process of sorting a list of elements using Merge Sort and list the complexity of this algorithm on various measures
• describe how the Quicksort algorithm partitions and sorts a list of elements
• recall the performance metrics of the Quicksort algorithm
• describe considerations for picking a sorting algorithm, list the properties of the Insertion Sort algorithm, and summarize the Shell Sort algorithm

Explore the workings of some of the most widely used sorting algorithms in Python and examine how their performance affects various measures.

Data Structures & Algorithms in Python: Trees & Graphs

Data Structures & Algorithms in Python: Trees & Graphs

• discover the key concepts covered in this course
• describe how a sorted list of elements can be searched efficiently using a binary search
• recognize what trees and binary trees are and recall the properties of a binary search tree
• summarize how insert and lookup operations occur in a BST
• identify the minimum and maximum values in a BST, identify the greatest depth of the data structure, and calculate the sum of values from the root to a leaf node
• recall the different ways in which to traverse a BST and describe the method to perform a breadth first traversal
• summarize the pre-order and in-order depth first traversal techniques for a BST
• describe the post-order traversal technique for a BST
• identify the components that make up a graph and recognize the different terms associated with these data structures
• recognize the different ways to represent graphs and describe the structure of an adjacency matrix
• summarize the representation of a graph in the form of an adjacency list and adjacency set
• traverse over the nodes in a graph using the topological sort algorithm
• summarize the properties of a binary search tree and list three different ways in which a graph can be represented

Examine the theory around graph and tree data structures in Python. Explore binary search trees, different graph representations, and traversal operations on these data structures.